// 个人中心页面处理
document.addEventListener('DOMContentLoaded', () => {
    console.log('个人中心页面初始化');
    
    // 是否使用Mock数据（当服务器不可用时）
    window.useMockApi = false;
    
    // 检查服务器状态
    checkApiStatus();
    
    // 检查API服务器状态
    async function checkApiStatus() {
        try {
            // 尝试调用API健康检查
            const response = await fetch('/api/health', { 
                method: 'GET',
                headers: { 'Accept': 'application/json' },
                // 设置超时，避免长时间等待
                signal: AbortSignal.timeout(3000)
            });
            if (response.ok) {
                console.log('API服务器正常运行');
                window.useMockApi = false;
            } else {
                console.warn('API服务器返回错误状态:', response.status);
                window.useMockApi = true;
            }
        } catch (error) {
            console.error('API服务器检查失败:', error);
            window.useMockApi = true;
            console.log('已启用Mock数据模式');
        }
    }
    
    // DOM元素
    const profileAvatar = document.getElementById('profileAvatar');
    const profileNickname = document.getElementById('profileNickname');
    const profileEmail = document.getElementById('profileEmail');
    const changeAvatarBtn = document.getElementById('changeAvatarBtn');
    const profileForm = document.getElementById('profileForm');
    const myVideosGrid = document.getElementById('myVideosGrid');
    const myCommentsList = document.getElementById('myCommentsList');
    
    // 表单元素
    const nicknameInput = document.getElementById('nickname');
    const phoneInput = document.getElementById('phone');
    const emailInput = document.getElementById('email');
    const currentPasswordInput = document.getElementById('currentPassword');
    const newPasswordInput = document.getElementById('newPassword');
    const confirmPasswordInput = document.getElementById('confirmPassword');
    
    // 检查用户是否已登录
    const token = localStorage.getItem('token');
    let user;
    
    try {
        user = JSON.parse(localStorage.getItem('user') || '{}');
    } catch (e) {
        user = {};
    }
    
    console.log('当前token:', token);
    console.log('当前用户信息:', user);
    
    // API请求帮助函数
    async function apiRequest(url, options, retries = 2) {
        const defaultOptions = {
            headers: {
                'Authorization': token ? `Bearer ${token}` : ''
            }
        };
        
        const requestOptions = { ...defaultOptions, ...options };
        
        // 合并headers
        if (options && options.headers) {
            requestOptions.headers = { ...defaultOptions.headers, ...options.headers };
        }
        
        let attempt = 0;
        
        while (attempt <= retries) {
            try {
                console.log(`发送请求到 ${url} (尝试 ${attempt + 1}/${retries + 1})`);
                const response = await fetch(url, requestOptions);
                
                // 处理响应
                let responseData;
                try {
                    // 检查响应类型是否为JSON
                    const contentType = response.headers.get('content-type');
                    console.log('响应Content-Type:', contentType);
                    
                    if (response.status === 204) {
                        // 204 No Content 响应
                        responseData = { success: true, message: '操作成功' };
                    } else if (!contentType) {
                        // 没有Content-Type头
                        const textResponse = await response.text();
                        console.warn('服务器响应没有Content-Type:', textResponse);
                        responseData = { message: textResponse || '操作成功', success: response.ok };
                    } else if (contentType.includes('application/json')) {
                        // JSON响应
                        const text = await response.text();
                        try {
                            responseData = JSON.parse(text);
                        } catch (jsonError) {
                            console.error('JSON解析失败，原始响应:', text);
                            throw new Error('服务器返回无效的JSON格式');
                        }
                    } else if (contentType.includes('text/plain')) {
                        // 纯文本响应
                        const textResponse = await response.text();
                        responseData = { message: textResponse, success: response.ok };
                    } else if (contentType.includes('text/html')) {
                        // HTML响应 - 可能是服务器错误页面
                        const textResponse = await response.text();
                        console.warn('服务器返回HTML响应:', textResponse.substring(0, 200) + '...');
                        
                        if (response.status === 404) {
                            throw new Error('请求的资源不存在 (404)');
                        } else if (response.status === 500) {
                            throw new Error('服务器内部错误 (500)');
                        } else {
                            throw new Error(`服务器返回HTML而非预期的JSON (状态码: ${response.status})`);
                        }
                    } else {
                        // 其他类型响应
                        const textResponse = await response.text();
                        console.warn(`未知响应类型 ${contentType}:`, textResponse.substring(0, 200) + '...');
                        responseData = { message: '操作已完成', success: response.ok, rawResponse: textResponse };
                    }
                } catch (parseError) {
                    console.error('解析服务器响应失败:', parseError);
                    
                    // 如果解析失败但响应成功，返回一个成功状态
                    if (response.ok) {
                        return { success: true, parseError: true };
                    }
                    
                    // 否则抛出错误
                    throw new Error('无法解析服务器响应');
                }
                
                // 判断响应状态
                if (!response.ok) {
                    // 特殊状态码处理
                    if (response.status === 401 || response.status === 403) {
                        // Token可能过期，提示用户重新登录
                        throw new Error(responseData.error || '登录已过期，请重新登录');
                    } else if (response.status === 400) {
                        throw new Error(responseData.error || '请求参数有误');
                    } else if (response.status === 429) {
                        // 请求过于频繁，等待后重试
                        if (attempt < retries) {
                            const waitTime = 1000 * Math.pow(2, attempt); // 指数退避
                            console.warn(`请求过于频繁，等待${waitTime}ms后重试`);
                            await new Promise(resolve => setTimeout(resolve, waitTime));
                            attempt++;
                            continue;
                        }
                        throw new Error('请求过于频繁，请稍后再试');
                    } else {
                        throw new Error(responseData.error || '请求失败');
                    }
                }
                
                // 成功响应
                return responseData;
                
            } catch (error) {
                // 网络错误处理
                if (error.name === 'TypeError' || error.message.includes('network')) {
                    if (attempt < retries) {
                        const waitTime = 1000 * Math.pow(2, attempt); // 指数退避
                        console.warn(`网络错误，等待${waitTime}ms后重试`);
                        await new Promise(resolve => setTimeout(resolve, waitTime));
                        attempt++;
                        continue;
                    }
                    throw new Error('网络连接失败，请检查您的网络连接');
                }
                
                // 其他错误直接抛出
                throw error;
            }
        }
    }
    
    if (!token && Object.keys(user).length === 0) {
        showMessage('请先登录后查看个人中心');
        profileNickname.textContent = '未登录';
        profileEmail.textContent = '请先登录';
        
        // 禁用表单
        if (profileForm) {
            profileForm.querySelectorAll('input').forEach(input => {
                input.disabled = true;
            });
            profileForm.querySelector('button').disabled = true;
        }
        return;
    }
    
    // 加载用户信息
    loadUserInfo();
    
    // 加载用户上传的视频
    loadUserVideos();
    
    // 加载用户评论
    loadUserComments();
    
    // 处理头像更新
    if (changeAvatarBtn) {
        changeAvatarBtn.addEventListener('click', () => {
            // 创建文件输入元素
            const fileInput = document.createElement('input');
            fileInput.type = 'file';
            fileInput.accept = 'image/*';
            fileInput.style.display = 'none';
            document.body.appendChild(fileInput);
            
            // 触发文件选择
            fileInput.click();
            
            // 监听文件选择
            fileInput.addEventListener('change', async (e) => {
                const file = e.target.files[0];
                if (!file) return;
                
                // 检查文件类型
                if (!file.type.startsWith('image/')) {
                    showMessage('只能上传图片文件');
                    return;
                }
                
                // 预览头像
                const reader = new FileReader();
                reader.onload = (e) => {
                    profileAvatar.src = e.target.result;
                };
                reader.readAsDataURL(file);
                
                // 上传头像
                await uploadAvatar(file);
                
                // 清理
                document.body.removeChild(fileInput);
            });
        });
    }
    
    // 处理表单提交
    if (profileForm) {
        // 密码强度检查
        if (newPasswordInput) {
            // 添加密码要求提示
            const passwordHint = document.createElement('div');
            passwordHint.className = 'password-requirements';
            passwordHint.textContent = '密码至少需要6个字符，建议包含字母、数字和特殊符号';
            newPasswordInput.parentNode.appendChild(passwordHint);
            
            // 添加密码强度指示器
            const strengthContainer = document.createElement('div');
            strengthContainer.className = 'password-strength';
            const strengthBar = document.createElement('div');
            strengthBar.className = 'password-strength-bar';
            strengthContainer.appendChild(strengthBar);
            newPasswordInput.parentNode.appendChild(strengthContainer);
            
            // 密码强度检测
            newPasswordInput.addEventListener('input', function() {
                const password = this.value;
                let strength = 0;
                
                // 基础长度检查
                if (password.length >= 6) strength += 1;
                if (password.length >= 10) strength += 1;
                
                // 包含数字
                if (/\d/.test(password)) strength += 1;
                
                // 包含小写字母
                if (/[a-z]/.test(password)) strength += 1;
                
                // 包含大写字母
                if (/[A-Z]/.test(password)) strength += 1;
                
                // 包含特殊字符
                if (/[^A-Za-z0-9]/.test(password)) strength += 1;
                
                // 更新强度显示
                strengthBar.className = 'password-strength-bar';
                if (strength <= 2) {
                    strengthBar.classList.add('strength-weak');
                    passwordHint.textContent = '弱密码：建议增加长度和复杂度';
                } else if (strength <= 4) {
                    strengthBar.classList.add('strength-medium');
                    passwordHint.textContent = '中等密码：可以再增加一些复杂度';
                } else {
                    strengthBar.classList.add('strength-strong');
                    passwordHint.textContent = '强密码：很好的密码强度';
                }
            });
        }

        profileForm.addEventListener('submit', async (e) => {
            e.preventDefault();
            
            // 验证表单
            if (newPasswordInput.value || confirmPasswordInput.value || currentPasswordInput.value) {
                // 密码相关字段有值，进行密码修改验证
                if (!currentPasswordInput.value) {
                    showMessage('请输入当前密码', 'error');
                    currentPasswordInput.focus();
                    return;
                }
                
                if (!newPasswordInput.value) {
                    showMessage('请输入新密码', 'error');
                    newPasswordInput.focus();
                    return;
                }
                
                if (newPasswordInput.value.length < 6) {
                    showMessage('新密码长度至少为6位', 'error');
                    newPasswordInput.focus();
                    return;
                }
                
                if (newPasswordInput.value !== confirmPasswordInput.value) {
                    showMessage('两次输入的新密码不一致', 'error');
                    confirmPasswordInput.focus();
                    return;
                }
            }
            
            // 提交表单
            await updateProfile();
        });
    }
    
    // 加载用户信息
    async function loadUserInfo() {
        try {
            console.log('开始从服务器获取用户信息');
            
            // 使用apiRequest替代直接fetch调用
            const userData = await apiRequest('/api/auth/user', {
                method: 'GET'
            });
            
            console.log('从API获取用户信息:', userData);
            
            // 更新页面显示
            if (profileAvatar) {
                // 确保头像路径有效
                let avatarSrc = userData.avatar || '/images/default-avatar.svg';
                // 如果是相对路径，确保正确
                if (avatarSrc.startsWith('/')) {
                    profileAvatar.src = avatarSrc;
                } else {
                    profileAvatar.src = '/' + avatarSrc;
                }
            }
            
            if (profileNickname) profileNickname.textContent = userData.nickname || '未设置昵称';
            if (profileEmail) profileEmail.textContent = userData.email || '未设置邮箱';
            
            // 填充表单
            if (nicknameInput) nicknameInput.value = userData.nickname || '';
            if (phoneInput) phoneInput.value = userData.phone || '';
            if (emailInput) emailInput.value = userData.email || '';
            
        } catch (error) {
            console.error('加载用户信息错误:', error);
            
            // 如果是登录过期错误，引导用户重新登录
            if (error.message.includes('登录已过期') || error.message.includes('401') || error.message.includes('403')) {
                showMessage('登录已过期，请重新登录', 'error');
                setTimeout(() => {
                    logout();
                }, 2000);
            } else {
                showMessage('获取用户信息失败: ' + error.message, 'error');
            }
        }
    }
    
    // 更新用户资料
    async function updateProfile() {
        try {
            console.log('开始更新用户资料');
            
            // 判断是否是密码修改
            const isPasswordChange = currentPasswordInput.value && newPasswordInput.value;
            
            // 分开处理密码修改和普通资料更新
            if (isPasswordChange) {
                await updatePassword();
            } else {
                await updateBasicInfo();
            }
            
        } catch (error) {
            console.error('更新资料错误:', error);
            showMessage(`${error.message}`, 'error');
        }
    }
    
    // 更新基本信息
    async function updateBasicInfo() {
        const profileData = {
            nickname: nicknameInput.value,
            phone: phoneInput.value,
            email: emailInput.value
        };
        
        console.log('提交的基本资料数据:', profileData);
        
        const formData = new FormData();
        for (const key in profileData) {
            formData.append(key, profileData[key]);
        }
        
        try {
            // 使用apiRequest替代直接fetch调用
            const result = await apiRequest('/api/users/profile', {
                method: 'PUT',
                body: formData
            });
            
            console.log('基本信息更新成功:', result);
            showMessage('个人资料更新成功', 'success');
            
            // 更新本地存储的用户信息
            const currentUser = JSON.parse(localStorage.getItem('user') || '{}');
            const newUserData = { 
                ...currentUser, 
                nickname: profileData.nickname,
                email: profileData.email,
                phone: profileData.phone
            };
            localStorage.setItem('user', JSON.stringify(newUserData));
            
            // 重新加载用户信息
            loadUserInfo();
            
        } catch (error) {
            console.error('更新基本信息失败:', error.message);
            showMessage('更新资料失败: ' + error.message, 'error');
            throw error;
        }
    }
    
    // 更新密码
    async function updatePassword() {
        const passwordData = {
            currentPassword: currentPasswordInput.value,
            newPassword: newPasswordInput.value,
            confirmPassword: confirmPasswordInput.value
        };
        
        console.log('准备更新密码');
        
        try {
            // 显示加载状态
            showMessage('正在更新密码...', 'info');
            
            // 调试信息
            console.log('密码更新请求数据:', JSON.stringify(passwordData));
            
            // 使用apiRequest替代直接fetch调用
            const result = await apiRequest('/api/users/password', {
                method: 'PUT',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify(passwordData)
            });
            
            // 请求成功
            console.log('密码更新返回结果:', result);
            
            // 清空密码字段
            currentPasswordInput.value = '';
            newPasswordInput.value = '';
            confirmPasswordInput.value = '';
            
            // 重置密码强度指示器
            const strengthBar = document.querySelector('.password-strength-bar');
            if (strengthBar) {
                strengthBar.className = 'password-strength-bar';
            }
            
            // 如果使用Mock数据，直接成功
            if (window.useMockApi) {
                showMessage('密码修改成功，请使用新密码重新登录', 'success');
                
                // 修改密码成功后3秒后登出
                setTimeout(() => {
                    try {
                        if (typeof logout === 'function') {
                            logout();
                        } else {
                            console.warn('logout函数不存在，直接清除token');
                            localStorage.removeItem('token');
                            localStorage.removeItem('user');
                            window.location.href = '/login.html';
                        }
                    } catch (e) {
                        console.error('退出登录失败:', e);
                        localStorage.removeItem('token');
                        localStorage.removeItem('user');
                        window.location.href = '/login.html';
                    }
                }, 3000);
                return;
            }
            
            showMessage('密码修改成功，请使用新密码重新登录', 'success');
            
            // 修改密码成功后3秒后登出
            setTimeout(() => {
                try {
                    logout();
                } catch (e) {
                    console.error('退出登录失败:', e);
                    localStorage.removeItem('token');
                    localStorage.removeItem('user');
                    window.location.href = '/login.html';
                }
            }, 3000);
            
        } catch (error) {
            // 错误已经在apiRequest中经过处理
            console.error('更新密码失败:', error.message);
            
            // 根据错误类型显示不同消息
            if (error.message.includes('密码') || error.message.includes('参数')) {
                showMessage(error.message, 'error');
            } else if (error.message.includes('登录已过期')) {
                showMessage('登录状态已过期，请重新登录', 'error');
                setTimeout(() => {
                    logout();
                }, 2000);
            } else if (error.message.includes('JSON') || error.message.includes('解析')) {
                showMessage('服务器响应格式错误，请联系管理员', 'error');
            } else if (error.message.includes('HTML')) {
                showMessage('服务器返回了错误页面，请稍后再试', 'error');
            } else {
                showMessage('密码修改失败: ' + error.message, 'error');
            }
            
            throw error;
        }
    }
    
    // 上传头像
    async function uploadAvatar(file) {
        try {
            let avatarUrl;
            
            const formData = new FormData();
            formData.append('avatar', file);
            
            const response = await fetch('/api/users/avatar', {
                method: 'POST',
                headers: {
                    'Authorization': `Bearer ${token}`
                },
                body: formData
            });
            
            // 检查响应的内容类型
            const contentType = response.headers.get('content-type');
            let responseData;
            
            if (contentType && contentType.includes('application/json')) {
                // 如果是JSON响应，正常解析
                responseData = await response.json();
            } else {
                // 如果不是JSON响应，获取文本并记录错误
                const textResponse = await response.text();
                console.error('服务器返回非JSON响应:', textResponse);
                throw new Error('服务器返回了无效的响应格式');
            }
            
            if (!response.ok) {
                throw new Error(responseData.error || '上传头像失败');
            }
            
            avatarUrl = responseData.avatar;
            
            showMessage('头像更新成功', 'success');
            
            // 更新本地存储的用户信息
            const currentUser = JSON.parse(localStorage.getItem('user') || '{}');
            localStorage.setItem('user', JSON.stringify({ ...currentUser, avatar: avatarUrl }));
            
        } catch (error) {
            console.error('上传头像错误:', error);
            showMessage(`上传头像失败: ${error.message}`, 'error');
        }
    }
    
    // 加载用户上传的视频
    async function loadUserVideos() {
        if (!myVideosGrid) return;
        
        try {
            console.log('开始从服务器获取用户视频数据');
            myVideosGrid.innerHTML = '<p class="loading-message">正在加载视频列表...</p>';
            
            // 获取所有视频，然后客户端筛选
            const response = await fetch('/api/videos?pageSize=100', {
                method: 'GET',
                headers: {
                    'Authorization': `Bearer ${token}`
                }
            });
            
            if (!response.ok) {
                throw new Error('获取视频列表失败');
            }
            
            // 检查响应的内容类型
            const contentType = response.headers.get('content-type');
            let data;
            
            if (contentType && contentType.includes('application/json')) {
                // 如果是JSON响应，正常解析
                data = await response.json();
            } else {
                // 如果不是JSON响应，获取文本并记录错误
                const textResponse = await response.text();
                console.error('服务器返回非JSON响应:', textResponse);
                throw new Error('服务器返回了无效的响应格式');
            }
            
            console.log('从API获取的所有视频:', data);
            
            // 筛选当前用户的视频
            const userVideos = data.videos.filter(video => 
                video.author && (video.author.id === user.id || 
                                video.uploaderId === user.id || 
                                video.userId === user.id)
            );
            
            console.log('筛选后的用户视频:', userVideos);
            
            if (!userVideos || userVideos.length === 0) {
                myVideosGrid.innerHTML = '<p class="empty-message">您还没有上传过视频</p>';
                return;
            }
            
            // 渲染视频列表
            myVideosGrid.innerHTML = '';
            userVideos.forEach(video => {
                const videoCard = createVideoCard(video);
                myVideosGrid.appendChild(videoCard);
            });
            
        } catch (error) {
            console.error('加载视频列表错误:', error);
            myVideosGrid.innerHTML = '<p class="error-message">加载视频列表失败，请稍后重试</p>';
        }
    }
    
    // 创建视频卡片
    function createVideoCard(video) {
        console.log('创建视频卡片:', video);
        const card = document.createElement('div');
        card.className = 'video-card';
        
        // 创建视频缩略图容器
        const thumbnailContainer = document.createElement('div');
        thumbnailContainer.className = 'video-thumbnail';
        
        // 创建图片元素用于显示缩略图
        const imgElement = document.createElement('img');
        imgElement.alt = video.title;
        
        // 创建时长显示元素
        const durationElement = document.createElement('div');
        durationElement.className = 'video-duration';
        
        // 如果有视频时长，直接显示
        if (video.duration) {
            durationElement.textContent = formatDuration(video.duration);
        } else {
            // 如果没有时长，创建视频元素来获取时长
            const videoElement = document.createElement('video');
            videoElement.className = 'video-preview';
            videoElement.preload = 'metadata';
            videoElement.muted = true;
            videoElement.src = video.url;
            
            // 当视频加载完成后，获取时长并显示
            videoElement.addEventListener('loadedmetadata', () => {
                durationElement.textContent = formatDuration(videoElement.duration);
                // 设置当前时间为第一帧
                videoElement.currentTime = 0;
            });
            
            // 如果图片加载失败，显示视频预览
            imgElement.onerror = () => {
                imgElement.style.display = 'none';
                videoElement.style.display = 'block';
                thumbnailContainer.appendChild(videoElement);
            };
        }
        
        // 设置图片源
        imgElement.src = video.thumbnail || '/images/default-thumbnail.jpg';
        imgElement.style.display = 'block';
        
        // 添加元素到容器
        thumbnailContainer.appendChild(imgElement);
        thumbnailContainer.appendChild(durationElement);
        
        // 添加播放按钮覆盖层
        const overlayElement = document.createElement('div');
        overlayElement.className = 'video-overlay';
        overlayElement.innerHTML = '<i class="fas fa-play"></i>';
        thumbnailContainer.appendChild(overlayElement);
        
        // 获取日期 - 支持多种日期字段名称
        const dateValue = video.createTime || video.createdAt || video.createDate || new Date().toISOString();
        
        // 创建视频信息容器
        const infoContainer = document.createElement('div');
        infoContainer.className = 'video-info';
        infoContainer.innerHTML = `
            <h3 class="video-title">${video.title}</h3>
            <div class="video-meta">
                <span class="video-date">${formatDate(dateValue)}</span>
                <span class="video-views"><i class="fas fa-eye"></i> ${formatNumber(video.views || 0)}</span>
            </div>
            <div class="video-actions">
                <button class="btn btn-sm btn-edit" data-id="${video.id}">编辑</button>
                <button class="btn btn-sm btn-delete" data-id="${video.id}">删除</button>
            </div>
        `;
        
        // 组装卡片
        card.appendChild(thumbnailContainer);
        card.appendChild(infoContainer);
        
        // 添加点击事件 - 编辑按钮
        const editBtn = infoContainer.querySelector('.btn-edit');
        editBtn.addEventListener('click', (e) => {
            e.stopPropagation();
            editVideo(video.id);
        });
        
        // 添加点击事件 - 删除按钮
        const deleteBtn = infoContainer.querySelector('.btn-delete');
        deleteBtn.addEventListener('click', (e) => {
            e.stopPropagation();
            deleteVideo(video.id);
        });
        
        // 添加点击事件 - 卡片点击跳转到视频页面
        card.addEventListener('click', () => {
            window.location.href = `/video/${video.id}`;
        });
        
        return card;
    }
    
    // 加载用户评论
    async function loadUserComments() {
        if (!myCommentsList) return;
        
        // 评论功能暂时不可用，显示替代消息
        myCommentsList.innerHTML = '<p class="info-message">暂时无法显示评论历史记录。我们正在努力完善此功能。</p>';
        
        /* 
        // 以下代码是未来实现评论API后可以使用的代码
        try {
            console.log('开始从服务器获取用户评论数据');
            myCommentsList.innerHTML = '<p class="loading-message">正在加载评论列表...</p>';
            
            const response = await fetch('/api/comments/my-comments', {
                method: 'GET',
                headers: {
                    'Authorization': `Bearer ${token}`
                }
            });
            
            if (!response.ok) {
                throw new Error('获取评论列表失败');
            }
            
            const data = await response.json();
            const comments = data.comments;
            console.log('从API获取评论列表:', comments);
            
            if (!comments || comments.length === 0) {
                myCommentsList.innerHTML = '<p class="empty-message">您还没有发表过评论</p>';
                return;
            }
            
            // 渲染评论列表
            myCommentsList.innerHTML = '';
            comments.forEach(comment => {
                const commentItem = createCommentItem(comment);
                myCommentsList.appendChild(commentItem);
            });
            
        } catch (error) {
            console.error('加载评论列表错误:', error);
            myCommentsList.innerHTML = '<p class="error-message">加载评论列表失败，请稍后重试</p>';
        }
        */
    }
    
    // 创建评论项
    function createCommentItem(comment) {
        const item = document.createElement('div');
        item.className = 'comment-item';
        item.innerHTML = `
            <div class="comment-video">
                <a href="/video/${comment.videoId}">${comment.videoTitle}</a>
            </div>
            <div class="comment-text">${comment.content}</div>
            <div class="comment-date">${formatDate(comment.createTime)}</div>
            <button class="btn btn-sm btn-delete" data-id="${comment.id}">删除</button>
        `;
        
        // 添加删除事件
        item.querySelector('.btn-delete').addEventListener('click', () => {
            deleteComment(comment.id);
        });
        
        return item;
    }
    
    // 编辑视频信息
    function editVideo(videoId) {
        console.log('编辑视频:', videoId);
        window.location.href = `/edit-video/${videoId}`;
    }
    
    // 删除视频
    async function deleteVideo(videoId) {
        // 创建自定义确认对话框
        const confirmDialog = document.createElement('div');
        confirmDialog.className = 'confirm-dialog';
        confirmDialog.innerHTML = `
            <div class="confirm-dialog-content">
                <h3>确认删除</h3>
                <p>您确定要删除这个视频吗？此操作不可恢复，视频将被永久删除。</p>
                <div class="confirm-dialog-buttons">
                    <button class="btn btn-secondary cancel-btn">取消</button>
                    <button class="btn btn-danger confirm-btn">删除</button>
                </div>
            </div>
        `;
        
        document.body.appendChild(confirmDialog);
        
        // 点击对话框外部关闭
        confirmDialog.addEventListener('click', (e) => {
            if (e.target === confirmDialog) {
                document.body.removeChild(confirmDialog);
            }
        });
        
        // 设置按钮操作
        const cancelBtn = confirmDialog.querySelector('.cancel-btn');
        const confirmBtn = confirmDialog.querySelector('.confirm-btn');
        
        cancelBtn.addEventListener('click', () => {
            document.body.removeChild(confirmDialog);
        });
        
        // 等待用户确认
        const userConfirmed = await new Promise((resolve) => {
            confirmBtn.addEventListener('click', () => {
                document.body.removeChild(confirmDialog);
                resolve(true);
            });
            
            cancelBtn.addEventListener('click', () => {
                resolve(false);
            });
        });
        
        if (!userConfirmed) {
            return;
        }
        
        // 显示加载状态
        showMessage('正在删除视频...', 'info');
        
        try {
            // 使用apiRequest替代直接fetch调用
            const result = await apiRequest(`/api/videos/${videoId}`, {
                method: 'DELETE'
            });
            
            console.log('删除视频结果:', result);
            showMessage('视频已成功删除', 'success');
            
            // 重新加载视频列表
            loadUserVideos();
            
        } catch (error) {
            console.error('删除视频错误:', error);
            
            // 处理特定的错误
            if (error.message.includes('权限') || error.message.includes('403')) {
                showMessage('您没有权限删除此视频', 'error');
            } else if (error.message.includes('不存在') || error.message.includes('404')) {
                showMessage('视频不存在或已被删除', 'error');
                // 仍然重新加载，以防视频列表不同步
                loadUserVideos();
            } else {
                showMessage(`删除视频失败: ${error.message}`, 'error');
            }
        }
    }
    
    // 删除评论
    async function deleteComment(commentId) {
        if (!confirm('确定要删除这条评论吗？')) {
            return;
        }
        
        try {
            let success = false;
            
            const response = await fetch(`/api/comments/${commentId}`, {
                method: 'DELETE',
                headers: {
                    'Authorization': `Bearer ${token}`
                }
            });
            
            if (!response.ok) {
                throw new Error('删除评论失败');
            }
            
            success = true;
            
            if (success) {
                showMessage('评论已成功删除', 'success');
                
                // 重新加载评论列表
                loadUserComments();
            } else {
                throw new Error('删除评论失败');
            }
            
        } catch (error) {
            console.error('删除评论错误:', error);
            showMessage(`删除评论失败: ${error.message}`, 'error');
        }
    }
    
    // 格式化时长
    function formatDuration(seconds) {
        const minutes = Math.floor(seconds / 60);
        const remainingSeconds = Math.floor(seconds % 60);
        return `${minutes}:${remainingSeconds.toString().padStart(2, '0')}`;
    }
    
    // 格式化数字
    function formatNumber(num) {
        if (num >= 10000) {
            return (num / 10000).toFixed(1) + 'w';
        }
        return num.toString();
    }
    
    // 格式化日期
    function formatDate(dateString) {
        const date = new Date(dateString);
        const now = new Date();
        const diff = now - date;
        
        // 一小时内
        if (diff < 60 * 60 * 1000) {
            return Math.floor(diff / (60 * 1000)) + '分钟前';
        }
        
        // 一天内
        if (diff < 24 * 60 * 60 * 1000) {
            return Math.floor(diff / (60 * 60 * 1000)) + '小时前';
        }
        
        // 一周内
        if (diff < 7 * 24 * 60 * 60 * 1000) {
            return Math.floor(diff / (24 * 60 * 60 * 1000)) + '天前';
        }
        
        // 具体日期
        return date.getFullYear() + '-' + 
               (date.getMonth() + 1).toString().padStart(2, '0') + '-' + 
               date.getDate().toString().padStart(2, '0');
    }
    
    // 显示消息
    function showMessage(message, type = 'info') {
        // 创建消息元素
        const messageEl = document.createElement('div');
        messageEl.className = `message message-${type}`;
        messageEl.textContent = message;
        
        // 添加到页面
        document.body.appendChild(messageEl);
        
        // 2秒后自动移除
        setTimeout(() => {
            messageEl.classList.add('fadeout');
            setTimeout(() => {
                document.body.removeChild(messageEl);
            }, 500);
        }, 3000);
    }
}); 